﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System;
using System.IO;
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;


namespace Maszyna
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

        }

        private void button2_Click(object sender, System.EventArgs e)
        {
            Stream myStream = null;
            OpenFileDialog openFileDialog1 = new OpenFileDialog(); //tworzy nowe okno otwierania pliku

            openFileDialog1.InitialDirectory = "c:\\";  //domyslna lokalizacją jest c:\
            openFileDialog1.Filter = "txt files (*.txt)|*.txt"; //obsługiwany typ plików to txt
            openFileDialog1.FilterIndex = 1; //jest to jedyny akcepowalny format


            if (openFileDialog1.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    if ((myStream = openFileDialog1.OpenFile()) != null)
                    {
                        using (myStream)
                        {

                            string file = openFileDialog1.FileName;
                            textBox45.Text = File.ReadAllText(file); //przepisuje cały napotkany tekst do wybranego pola
                        }
                    }
                    myStream.Close(); //zamyka plik
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Error: Nie można odczytać pliku. Sczegóły: " + ex.Message); //jeśli nie uda się odworzyc pliku wyswietlany jest komunikat
                }
            }
        }

        private void button3_Click(object sender, System.EventArgs e)
        {
            SaveFileDialog saveFileDialog1 = new SaveFileDialog(); //tworzone jest nowe okno zapisu
            saveFileDialog1.Filter = "Text Files (*.txt)|*.txt|All Files (*.*)|*.*"; //pliki zapisywane są w formacie txt
            saveFileDialog1.FilterIndex = 1; //jest to jedyny format
            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                StreamWriter myStream = new StreamWriter(saveFileDialog1.FileName, false); //plik jest zapisywany, nadpisuje pliki po uprzednim alercie
                myStream.Write(textBox45.Text); //zapis pola tekstowego
                myStream.Close(); // zamkniecie pliku
            }
        }



        //_______________________________________________________________
        private void button1_Click(object sender, EventArgs e)
        {
            int linia = 1;
            char c;
            int zgodnosc = 0;

            int z = 0;
            int b = 0;
            int j = 0;
            int twyj = 0;
            int temp;

            //oznaczenie etykiet
            List<char[]> etykiety = new List<char[]>();
            List<int> index_etykiety = new List<int>();
            List<char> etykieta = new List<char>();
            List<char> etykieta_temp = new List<char>();
            char[] et = new char[1];
            char[] et_tmp = new char[1];


            int t = 0;
            int y = 0;
            char[] rozkaz = new char[7];


            int[] tab = new int[18];
            for (int i = 0; i < 18; i++)
            {

                tab[i] = 0;
            }
            try
            {                                //<=========================TRY========
                Stopwatch clock = new Stopwatch();
                clock.Start();


                //+++++++++++++++++++++++++++++++ODCZY Z TASMY WEJCIOWEJ+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

                int m = 0;
                char[] pole = textBox45.Text.ToCharArray(); //odczyt kodu programu z odpowiedniego pola tekstowego
                for (int i = 0; i < 18; i++)
                {
                    if (t_Wej[i].Text != "") tab[i] = Int32.Parse(t_Wej[i].Text); //odczyt danych z pól tekstowych taśmy wejściowej
                    else tab[i] = 0;
                }
                //           tasma wejsciowa

                tasma_wejsciowa[] tasmaa = new tasma_wejsciowa[18];
                for (int i = 0; i < 18; i++)
                {
                    tasmaa[i] = new tasma_wejsciowa(tab[i]);
                }


                //tasma wyjsciowa
                tasma_wyjsciowa[] tasmab = new tasma_wyjsciowa[18];
                for (int i = 0; i < 18; i++)
                {
                    tasmab[i] = new tasma_wyjsciowa();
                }
                //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                //rejestry

                progressBar1.Value = 10;
                rejestr[] rej = new rejestr[8];
                for (int i = 0; i < 8; i++) { rej[i] = new rejestr(); }
                //kod programu



                //char [] order = rozkaz.ToCharArray();

                //---------------------------------------------ETYKIETY--------------------------------------------------------
                int et_ind = 0;
                while ((et_ind != pole.Length))
                {  //przeszukuje cale pole tekstowe w poszukiwanie etykiet
                    if (pole[et_ind] == 'J') //jesli napotka 'J' w rozkazie skoku ignoruje male litery do konca wiersza
                    {
                        while (pole[et_ind] != '\n' && pole[et_ind] != '0')
                        {
                            et_ind++;
                        }
                        // et_ind++;
                    }
                    if (pole[et_ind] == ';') //jesli napotka ';' w rozkazie skoku ignoruje male litery do konca wiersza
                    {
                        while (pole[et_ind] != '\n' && pole[et_ind] != '0')
                        {
                            et_ind++;
                        }
                        //  et_ind++;
                    }
                    if ((int)pole[et_ind] > 96 && (int)pole[et_ind] < 123) //jeśli napotka mala litere 
                    {
                        while (pole[et_ind] != ':')             //do momentu napotkania ':'
                        {
                            etykieta.Add(pole[et_ind]);             //dodaje znaki do wektora "etykieta"
                            et_ind++;                   //przechodzi do nastepnego znaku
                        }
                        et_ind++; //przechodzi do nastepnego znaku (pomija znak ':')
                        int size = etykieta.Count() + 1; //pobierana jest wielkosc wektora  <--------------------TU BLAD
                        et = new char[size + 1]; et[size - 1] = '\0'; //tworzy ciag znaków o dlugosci size
                        for (int s = 0; s < size - 1; s++)
                        {

                            et = etykieta.ToArray(); //ciag zapelniany jest elementami wektora etykieta
                        }

                        etykiety.Add(et);      // <--------------------TU BLAD
                        index_etykiety.Add(et_ind + 1); //indeks znaku bezposrednio za etykieta zostaje zapamietany do skoku
                        etykieta.Clear(); //wektor etykieta zostaje wyczyszczony
                        continue;
                    }
                    else //jeśli napotka inny znak pomija go
                    {
                        et_ind++;
                        continue;
                    }


                }
                //---------------------------------------------------------------------------------------------------------------
                progressBar1.Value = 30;
                //interpretacja kodu
                //_____________________________________________________________________________________________
                while (true)
                {
                    if (z == pole.Length) throw new NullReferenceException(); //jesli napotka koniec tekstu bez rozkazu HLT zglosi wyjatek
                    if ((int)pole[z] == 13) { z++; continue; } //jesli napotka '\r' pomija go
                    if ((int)pole[z] == 10) //jesli napotka znak '\n'  
                    {
                        j = 0; //zeruje indeks rozkazu
                        z += 1;  //przechodzi do nastepnego znaku
                        linia++; //inkrementuje zmienna linia 
                        continue;
                    }

                    if (z == pole.Length) throw new NullReferenceException();  //jesli napotka koniec tekstu bez rozkazu HLT zglosi wyjatek
                    if (pole[z] == ';') // gny napotka srednik pomija reszte znaków az do konca wiersza, gdyz to komentarz
                    {
                        while (pole[z] != '\n' && z != pole.Length) //pomijanie znaków do konca wiersza lub tekstu
                        {
                            z++;
                        }
                        continue;
                    }

                    if ((int)pole[z] > 64 && (int)pole[z] < 91)
                    { //jesli napotka wielka litere rozpocznie pobieranie rozkazu
                        while (pole[z] != ' ') //do napotkania spacji
                        {
                            if (z == pole.Length) throw new NullReferenceException(); //jesli napotka koniec tekstu bez rozkazu HLT zglosi wyjatek
                            if (((int)pole[z] >= 91 || (int)pole[z] < 65) && (int)pole[z] != 32) throw new ArrayTypeMismatchException(); //jesli napotka na nieprawidlowy znak zglosi wyjatek
                            //jesli natrafi na znak różny od wielkiej litery lub spacji zgłosi wyjątek
                            c = pole[z]; //do zmiennej char c pobierany jest znak z pola
                            z++;
                            rozkaz[j] = c; j++; //znak ten jest dodawany do rozkazu
                            rozkaz[6] = '\0'; //dodanie terminatora
                            if (rozkaz[0] == 'H' && rozkaz[1] == 'L') break; //rozkaz HLT przerywa petle

                        }
                    }


                    if (rozkaz[0] == 'H' && rozkaz[1] == 'L') break;//rozkaz HLT przerywa petle
                    if ((int)pole[z] > 64 && (int)pole[z] < 91) continue;

                    //---------------------ETYKIETY-------------------------------------

                    if ((int)pole[z] > 96 && (int)pole[z] < 123) { z++; continue; } //jezeli napotka na mala litere uzna, ze to etykieta i ja pominie
                    if ((int)pole[z] == 58) { z++; continue; } // tak samo ze znakiem ':'

                    //----------------------------------------------------------------------




                    // interpretacja polecen
                    //==============================================================================	
                    if (rozkaz[0] == 'R' && rozkaz[1] == 'E')
                    {
                        z++; //pomija znak spacji


                        if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); ; //jesli napotka znak inny niz liczba zglosi wyjatek
                        c = pole[z]; z++; //zapisuje wartosc pola do zmiennej char
                        temp = ((int)c) - 48; //wartosc char zostaje odpowiednio przekonwertowana na int
                        if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jesli odwolujemy sie do rejestru poza zakresem zgloszony zostaje wyjatek
                        if (m >= 18) throw new FormatException(); //wyjatek przekroczenia zakresu tasmy
                        rej[temp].store(tasmaa[m].read()); //do rejestru o indeksie temp zapisana jest wartosc tasmy
                        m++; j = 0; //indeks tasmy przesuwa się do przodu, indeks rozkazu zostaje wyzerowany
                        continue;
                    }
                    else if (rozkaz[0] == 'W' && rozkaz[1] == 'R')
                    {
                        z++; //pomija spacje

                        if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); ;//jesli napotka znak inny niz liczba zglosi wyjatek
                        c = pole[z]; z++; //zapisuje wartosc pola do zmiennej char
                        //if ((int)c == 0 || c == '\n' || (int)c <65 || (int) c > 90) 
                        temp = ((int)c) - 48; j = 0; //wartosc char zostaje odpowiednio przekonwertowana na int, zeruje indeks rozkazu
                        if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jesli odwolujemy sie do rejestru poza zakresem zgloszony zostaje wyjatek
                        if (twyj >= 18) throw new FormatException(); //wyjatek przekroczenia zakresu tasmy

                        tasmab[twyj].write(rej[temp].load()); //z rejestru o indeksie temp sczytywana jest wartosc do tasmy wyjsciowej
                        twyj++; continue; //inkrementuje indeks tasmy wyjsciowej

                    }
                    else if (rozkaz[0] == 'L' && rozkaz[1] == 'O')
                    {
                        z++;	//pomija spacje
                        if (pole[z] == ';') continue;
                        if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                        c = pole[z]; z++;  //zapisuje wartosc pola do zmiennej char
                        temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                        if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jesli odwolujemy sie do rejestru poza zakresem zgloszony zostaje wyjatek
                        rej[0].store((rej[temp].load())); //do akumulatora zostaje wczytana zawartosc rejestru o indeksie temp
                        j = 0;//zeruje indeks rozkazu
                        continue;

                    }
                    else if (rozkaz[0] == 'S' && rozkaz[1] == 'T')
                    {

                        z++;//pomija spacje

                        if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                        c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                        temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                        if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jesli odwolujemy sie do rejestru poza zakresem zgloszony zostaje wyjatek
                        rej[temp].store(rej[0].load());//do rejestru z indeksem temp zostaje zapisana zawartosc akumulatora
                        j = 0;  //zeruje indeks rozkazu
                        continue;
                    }


                    else if (rozkaz[0] == 'A' && rozkaz[1] == 'D')
                    {

                        z++;//pomija spacje
                        c = pole[z];//zapisuje wartosc pola do zmiennej char
                        if (((int)c) == 61) //jesli napotka znak '=' pobiera stala
                        {
                            z++;//pomija znak '='
                            c = pole[z];//zapisuje wartosc pola do zmiennej char
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            z++;
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                            if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jeśli odwołujemy się do rejestru poza zakresem zgłoszony zostaje wyjątek
                            rej[0].add(temp); //do akumulatora dodana zostaje wartowsc temp
                        }
                        else
                        {
                            if (pole[z] == ';')
                            {
                                while (pole[z] != '\n' || z == pole.Length)
                                {
                                    z++;
                                }

                            }
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                            rej[0].add(rej[temp].load());//do akumulatora dodana zostaje wartowsc rejestru o indeksie temp
                        }
                        j = 0;//zeruje indeks rozkazu

                        continue;
                    }



                    else if (rozkaz[0] == 'S' && rozkaz[1] == 'U')
                    {

                        z++;//pomija spacje
                        c = pole[z];//zapisuje wartosc pola do zmiennej char
                        if (((int)c) == 61) //jesli napotka znak '=' pobiera stala
                        {
                            z++; //pomija znak '='
                            c = pole[z];//zapisuje wartosc pola do zmiennej char
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            z++;
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                            rej[0].sub(temp); //od akumulatora odjeta zostaje wartowsc temp
                        }
                        else
                        {
                            if (pole[z] == ';')
                            {
                                while (pole[z] != '\n' || z == pole.Length)
                                {
                                    z++;
                                }

                            }
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                            if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jeśli odwołujemy się do rejestru poza zakresem zgłoszony zostaje wyjątek
                            rej[0].sub(rej[temp].load());//od akumulatora odjeta zostaje wartowsc rejestru o indeksie temp
                        }

                        j = 0; z++;//zeruje indeks rozkazu
                        continue;
                    }

                    else if (rozkaz[0] == 'D' && rozkaz[1] == 'I')
                    {
                        z++;//pomija spacje
                        c = pole[z];//zapisuje wartosc pola do zmiennej char
                        if (((int)c) == 61) //jesli napotka znak '=' pobiera stala
                        {
                            z++;//pomija znak '='
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int

                            if (temp == 0) throw new DivideByZeroException(); //zgloszenie dzielenia przez zero

                            rej[0].div(temp); //akumulator zostaje podzielony przez wartosc temp
                        }
                        else
                        {
                            if (pole[z] == ';')
                            {
                                while (pole[z] != '\n' || z == pole.Length)
                                {
                                    z++;
                                }

                            }
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                            if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jeśli odwołujemy się do rejestru poza zakresem zgłoszony zostaje wyjątek
                            if (rej[temp].load() == 0) throw new DivideByZeroException();//zgloszenie dzielenia przez zero
                            rej[0].div(rej[temp].load());//akumulator zostaje podzielony przez wartosc rejestru o indeksie temp
                        }

                        j = 0;//zeruje indeks rozkazu
                        continue;
                    }
                    else if (rozkaz[0] == 'M' && rozkaz[1] == 'U')
                    {
                        z++;//pomija spacje
                        c = pole[z];//zapisuje wartosc pola do zmiennej char
                        if (((int)c) == 61) //jesli napotka znak '=' pobiera stala
                        {
                            z++;
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek;
                            c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int

                            rej[0].mult(temp);//akumulator zostaje pomnożony przez wartosc temp
                        }
                        else
                        {
                            if (pole[z] == ';') continue;
                            if ((int)pole[z] < 48 || (int)pole[z] > 57) throw new ArrayTypeMismatchException(); //jesli napotka znak inny niz liczba zglosi wyjatek
                            c = pole[z]; z++;//zapisuje wartosc pola do zmiennej char
                            temp = ((int)c) - 48;//wartosc char zostaje odpowiednio przekonwertowana na int
                            if (temp < 0 || temp > 7) throw new ArrayTypeMismatchException();  //jeśli odwołujemy się do rejestru poza zakresem zgłoszony zostaje wyjątek
                            rej[0].mult(rej[temp].load());//akumulator zostaje pomnożony przez wartosc rejestru o indeksie temp 
                        }
                        j = 0;//zeruje indeks rozkazu
                        continue;

                    }
                    else if (rozkaz[0] == 'J' && rozkaz[1] == 'U')
                    {
                        z++; //pomija spacje
                        while ((int)pole[z] != 13 && pole[z] != ';') //do napotkania znaku '\r'
                        {
                            if (pole[z] == ';') continue;
                            if (z == pole.Length) throw new NullReferenceException();  //jesli napotka koniec programu bez HLT zglosi wyjatek
                            if (((int)pole[z] == 10 || (int)pole[z] < 97 || (int)pole[z] > 122) && (int)pole[z] != 58) throw new ArrayTypeMismatchException();
                            //jesli napotka znak inny niz mala litera zglosi wyjatek
                            etykieta_temp.Add(pole[z]); //do wektora etykieta_temp dodawane sa znaki z pola
                            z++;
                        }

                        int size = etykieta_temp.Count() + 1;// 
                        et_tmp = new char[size + 1];//tworzy ciag znakow o dlugosci size
                        for (int s = 0; ; s++)
                        {
                            if (s >= etykieta_temp.Count()) break;//[ 
                            et_tmp = etykieta_temp.ToArray();//wypelnia go elementami wektora
                        }
                        for (int o = 0; o < etykiety.Count(); ++o) //sprawdzam czy etykieta pasuje do zbiotu etykiet
                        {
                            //for (int x = 0; ;x++ ){

                            if (et_tmp.Length == etykiety[o].Length)
                            {
                                for (int counter = 0; ; counter++)
                                {
                                    if (counter >= etykiety[o].Length) break;
                                    if (et_tmp[counter].Equals(etykiety[o][counter])) { zgodnosc++; continue; }//jesli tak
                                    else break;
                                }
                                if (zgodnosc == et_tmp.Length)
                                {
                                    z = index_etykiety[o]; zgodnosc = 0;
                                    break;

                                }
                            }

                        }
                        etykieta_temp.Clear();

                        j = 0;//zeruje indeks rozkazu
                        continue;
                    }
                    else if (rozkaz[0] == 'J' && rozkaz[1] == 'G')
                    {
                        if (rej[0].load() > 0)
                        {
                            z++; //pomija spacje

                            while ((int)pole[z] != 13 && pole[z] != ';') //do napotkania znaku '\r
                            {
                                if (z == pole.Length) throw new NullReferenceException();  //jesli napotka koniec programu bez HLT zglosi wyjatek
                                if (pole[z] == ';') continue;
                                if (((int)pole[z] == 10 || (int)pole[z] < 97 || (int)pole[z] > 122) && (int)pole[z] != 58) throw new ArrayTypeMismatchException();
                                //jesli napotka znak inny niz mala litera zglosi wyjatek
                                etykieta_temp.Add(pole[z]); //do wektora etykieta_temp dodawane sa znaki z pola
                                z++;
                            }

                            int size = etykieta_temp.Count();//odczyuje wielkosc wektora
                            et_tmp = new char[size];//et_tmp[size] = '\0';//tworzy ciag znakow o dlugosci size
                            for (int s = 0; ; s++)
                            {
                                if (s >= etykieta_temp.Count()) break;  //s>=(et_tmp.Length) || 
                                et_tmp = etykieta_temp.ToArray();//wypelnia go elementami wektora
                            }

                            for (int o = 0; o < etykiety.Count(); ++o) //sprawdzam czy etykieta pasuje do zbiotu etykiet
                            {
                                //for (int x = 0; ;x++ ){

                                if (et_tmp.Length == etykiety[o].Length)
                                {
                                    for (int counter = 0; ; counter++)
                                    {
                                        if (counter >= etykiety[o].Length) break;
                                        if (et_tmp[counter].Equals(etykiety[o][counter])) { zgodnosc++; continue; }//jesli tak
                                        else break;
                                    }
                                    if (zgodnosc == et_tmp.Length)
                                    {
                                        z = index_etykiety[o]; zgodnosc = 0;
                                        break;

                                    }
                                }

                            }
                            etykieta_temp.Clear();

                            j = 0;//zeruje indeks rozkazu
                            continue;
                        }
                        else z++; //w przeciwnym wypadku kontynuuje wykonanie progra
                    }
                    else
                        if (pole[z] == ';')
                        {
                            while (pole[z] != '\n' || z == pole.Length)
                            {
                                z++;
                            }

                        }

                        else if (rozkaz[0] == 'J' && rozkaz[1] == 'M')
                        {
                            if (rej[0].load() == 0)
                            {
                                z++; //pomija spacje
                                while ((int)pole[z] != 13 && pole[z] != ';') //do napotkania znaku '\r'
                                {

                                    if (z == pole.Length) throw new NullReferenceException(); //jesli napotka koniec programu bez HLT zglosi wyjatek
                                    if (((int)pole[z] == 10 || (int)pole[z] < 97 || (int)pole[z] > 122) && (int)pole[z] != 58) throw new ArrayTypeMismatchException();
                                    //jesli napotka znak inny niz mala litera zglosi wyjatek
                                    etykieta_temp.Add(pole[z]); //do wektora etykieta_temp dodawane sa znaki z pola
                                    z++;
                                }

                                int size = etykieta_temp.Count() + 1;//zczytuje wielkosc wektora
                                et_tmp = new char[size + 1]; et_tmp[size - 1] = '\0';//tworzy ciag znakow o dlugosci size
                                for (int s = 0; ; s++)
                                {
                                    if (s >= etykieta_temp.Count()) break;
                                    et_tmp = etykieta_temp.ToArray();//wypelnia go elementami wektora
                                }

                                for (int o = 0; o < etykiety.Count(); ++o) //sprawdzam czy etykieta pasuje do zbiotu etykiet
                                {
                                    //for (int x = 0; ;x++ ){

                                    if (et_tmp.Length == etykiety[o].Length)
                                    {
                                        for (int counter = 0; ; counter++)
                                        {
                                            if (counter >= etykiety[o].Length) break;
                                            if (et_tmp[counter].Equals(etykiety[o][counter])) { zgodnosc++; continue; }//jesli tak
                                            else break;
                                        }
                                        if (zgodnosc == et_tmp.Length)
                                        {
                                            z = index_etykiety[o];
                                            break;
                                        }
                                    }

                                }
                                etykieta_temp.Clear();

                                j = 0;//zeruje indeks rozkazu
                                continue;
                            }
                            else z++; //w przeciwnym wypadku kontynuuje wykonanie programu
                        }

                        else if (rozkaz[0] == 'H' && rozkaz[1] == 'L')
                        {
                            break;
                        } //HLT przerywa dzialanie petli
                        else throw new ArrayTypeMismatchException();
                }
                progressBar1.Value = 90;

                clock.Stop();
                textBox46.Text = (clock.Elapsed).ToString();

                //odczytywanie wartosci koncowych rejestrow do pol tekstowych
                //_____________________________________________________________
                for (int s = 0; s < 8; s++)
                {
                    registers[s].Text = rej[s].load().ToString();
                }
                //_______________________________________________________________
                //odczytywanie wartosci koncowych tasmy wyjsciowej do pol tekstowych
                //_____________________________________________________________

                for (int r = 0; r < 18; r++)
                {
                    t_Wyj[r].Text = tasmab[r].read().ToString();
                }
                //_____________________________________________________________

                etykiety.Clear();
                progressBar1.Value = 100;
                Thread.Sleep(1000);
                progressBar1.Value = 0;
            }


            catch (ArrayTypeMismatchException)
            {
                MessageBox.Show("Blad w linii " + linia.ToString() + "!!!");
            }
            catch (NullReferenceException)
            {
                MessageBox.Show("Brak HLT!!!");
            }
            catch (FormatException)
            {
                MessageBox.Show("Blad danych!!!");
            }
            catch (DivideByZeroException)
            {
                MessageBox.Show("Dzielenie przez 0!");
            }
            catch (Exception)
            {
                MessageBox.Show("Nieznany blad");
            }

        }




    }
}
